// pages/index/indexAnswer/AnsQues/AnsQues.js
let app=getApp();
Page({

  /**
   * 页面的初始数据
   */
  data: {
    url:'',
    id:0,
    question:'',
    answer:[],
    users:'',
    psych:''
    // autoIndex: 0
  },
  getPsych(){
    return new Promise((resolve) => {
      // 修正API URL格式
      const apiUrl = this.data.url.endsWith('/') ? 
        this.data.url + 'psych/ById/' + this.data.id : 
        this.data.url + '/psych/ById/' + this.data.id;
      
      console.log('获取心理咨询师数据，API URL:', apiUrl);
      
      wx.request({
        url: apiUrl,
        success: (resp) =>{
          console.log('获取心理咨询师响应：', resp.data);
          if (resp.data && resp.data.code === 200 && resp.data.data) {
            const psychData = resp.data.data;
            // 标准化心理咨询师数据结构
            const normalizedPsych = {
              id: psychData.id || this.data.id,
              name: psychData.name || '心理咨询师',
              description: psychData.description || psychData.desc || '专业心理咨询师',
              avatar: psychData.avatar || '',
              specialty: psychData.specialty || ''
            };
            
            this.setData({
              psych: normalizedPsych
            })
          } else {
            console.warn('心理咨询师数据异常：', resp.data);
            this.setData({
              psych: {
                id: this.data.id,
                name: '心理咨询师',
                description: '专业心理咨询师',
                avatar: '',
                specialty: ''
              }
            })
          }
        },
        fail: (err) => {
          console.error('获取心理咨询师失败：', err);
          this.setData({
            psych: {
              id: this.data.id,
              name: '心理咨询师',
              description: '专业心理咨询师',
              avatar: '',
              specialty: ''
            }
          })
        },
        complete: () => {
          resolve();
        }
      })
    });
  },
  // incrementIndex() {
  //   this.setData({
  //     // 利用当前值+1实现自增
  //     autoIndex: this.data.autoIndex + 1
  //   })
  //   // 可在这里添加自增后的逻辑，比如打印新值
  //   console.log('当前index:', this.data.autoIndex)
  // },
  getAnswer(){
    return new Promise((resolve) => {
      // 使用psyreply端点获取回复数据，与indexSerch.js保持一致
      const apiUrl = this.data.url.endsWith('/') ? 
        this.data.url + 'psyreply' : 
        this.data.url + '/psyreply';
      
      console.log('获取回复数据，API URL:', apiUrl);
      console.log('当前问题ID:', this.data.id);
      
      wx.request({
        url: apiUrl,
        method: 'GET',
        success:resp=>{
          console.log('获取用户回答响应：', resp.data);
          console.log('完整响应结构:', JSON.stringify(resp.data, null, 2));
          
          if (resp.data && (resp.data.code === 200 || resp.data.code === 0) && resp.data.data) {
            // 根据indexSerch.js的逻辑，回复数据在resp.data.data.list中
            let answerData = resp.data.data.list || [];
            console.log('原始回答数据:', answerData);
            console.log('原始回答数据长度:', answerData.length);
            
            // 过滤出当前问题的回复
            const currentQuestionId = parseInt(this.data.id);
            console.log('当前问题ID (转换后):', currentQuestionId);
            
            answerData = answerData.filter(item => {
              const itemQaId = parseInt(item.qaId);
              const itemQuestionId = parseInt(item.questionId);
              console.log(`检查回复项: qaId=${itemQaId}, questionId=${itemQuestionId}, 当前问题ID=${currentQuestionId}`);
              return itemQaId === currentQuestionId || itemQuestionId === currentQuestionId;
            });
            
            console.log('过滤后的回答数据:', answerData);
            console.log('过滤后的回答数据长度:', answerData.length);
            
            // 标准化回答数据结构
            const normalizedAnswers = answerData.map(item => ({
              id: item.id || 0,
              replyContent: item.replyContent || item.content || '',
              replyUserNickName: item.replyUserNickName || item.nickname || '用户',
              replyTime: item.replyTime || item.createTime || '',
              userId: item.userId || 0
            }));
            
            console.log('标准化后的回答数据:', normalizedAnswers);
            console.log('回答数量:', normalizedAnswers.length);
            
            this.setData({
              answer: normalizedAnswers
            }, () => {
              console.log('setData后的answer数据:', this.data.answer);
              console.log('setData后的answer长度:', this.data.answer.length);
            });
          } else {
            console.warn('用户回答数据异常：', resp.data);
            console.log('响应code:', resp.data?.code);
            console.log('响应data:', resp.data?.data);
            this.setData({
              answer: []
            })
          }
        },
        fail: err => {
          console.error('获取用户回答失败：', err);
          this.setData({
            answer: []
          })
        },
        complete: () => {
          resolve();
        }
      })
    });
  },
  getQuestion(){
    return new Promise((resolve) => {
      // 修正API URL格式，使用正确的psych端点
      const apiUrl = this.data.url.endsWith('/') ? 
        this.data.url + 'psych/ById/' + this.data.id : 
        this.data.url + '/psych/ById/' + this.data.id;
      
      console.log('获取问题详情，API URL:', apiUrl);
      
      wx.request({
        url: apiUrl,
        method: 'GET',
        success:resp=>{
          console.log('获取问题详情响应：', resp.data);
          if (resp.data && resp.data.code === 200 && resp.data.data) {
            const psychData = resp.data.data;
            if (psychData) {
              // 详细打印API返回的数据结构，便于调试
              console.log('API返回的psychData结构：', {
                id: psychData.id,
                title: psychData.title,
                content: psychData.content,
                description: psychData.description,
                name: psychData.name,
                createTime: psychData.createTime
              });
              
              // 获取所有可能的问题内容字段
              const possibleContents = [
                psychData.content,
                psychData.description,
                psychData.question
              ].filter(content => content && content.trim() !== '');
              
              // 获取所有可能的标题字段
              const possibleTitles = [
                psychData.title,
                psychData.name,
                psychData.question
              ].filter(title => title && title.trim() !== '');
              
              // 去重处理
              const uniqueContents = [...new Set(possibleContents)];
              const uniqueTitles = [...new Set(possibleTitles)];
              
              console.log('去重后的内容列表：', uniqueContents);
              console.log('去重后的标题列表：', uniqueTitles);
              
              // 选择最终显示的标题和内容
              let finalTitle = uniqueTitles[0] || '问题标题';
              let finalContent = '';
              
              // 更智能的内容选择策略
              if (uniqueContents.length > 0) {
                // 如果只有一个内容，直接使用
                if (uniqueContents.length === 1) {
                  finalContent = uniqueContents[0];
                } else {
                  // 如果有多个内容，优先选择与标题不同的内容
                  const differentContent = uniqueContents.find(content => content !== finalTitle);
                  if (differentContent) {
                    finalContent = differentContent;
                  } else {
                    // 如果所有内容都与标题相同，选择第一个内容（可能是详细描述）
                    finalContent = uniqueContents[0];
                  }
                }
              }
              
              // 特殊处理：如果内容与标题完全相同且长度较短，可能是重复数据，清空内容
              if (finalContent === finalTitle && finalContent.length < 50) {
                finalContent = '';
              }
              
              console.log('最终选择的标题：', finalTitle);
              console.log('最终选择的内容：', finalContent);
              
              // 标准化问题数据结构
              const normalizedQuestion = {
                id: psychData.id || this.data.id,
                title: finalTitle,
                content: finalContent,
                createTime: psychData.createTime || '',
                psychId: psychData.id || this.data.id
              };
              
              console.log('标准化后的问题数据：', normalizedQuestion);
              
              this.setData({
                question: normalizedQuestion,
                users: {}, // psych/ById端点不返回users信息
              })
            } else {
              console.warn('未找到问题数据');
              this.setData({
                question: {
                  id: this.data.id,
                  title: '问题标题',
                  content: '问题内容',
                  createTime: '',
                  psychId: this.data.id
                },
                users: {},
              })
            }
          } else {
            console.error('数据结构异常：', resp.data);
            this.setData({
              question: {
                id: this.data.id,
                title: '问题标题',
                content: '问题内容',
                createTime: '',
                psychId: this.data.id
              },
              users: {},
            })
          }
        },
        fail: err => {
          console.error('获取问题详情失败：', err);
          this.setData({
            question: {
              id: this.data.id,
              title: '问题标题',
              content: '问题内容',
              createTime: '',
              psychId: this.data.id
            },
            users: {},
          })
        },
        complete: () => {
          resolve();
        }
      })
    });
  },
  // 提供给回复页回退后刷新
  reloadData(){
    console.log('重新加载数据');
    return this.loadAllData().then(() => {
      console.log('数据重新加载完成');
      // 可以在这里添加额外的刷新逻辑，比如显示提示
      wx.showToast({
        title: '数据已更新',
        icon: 'success',
        duration: 1000
      });
    });
  },
  gotoReply(){
    console.log('跳转到回复页面，问题ID:', this.data.id);
    wx.navigateTo({
      url: `/pages/index/indexAnswer/AnsQues/reply/reply?id=${this.data.id}`,
      success: () => {
        console.log('成功跳转到回复页面');
      },
      fail: (err) => {
        console.error('跳转到回复页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none'
        });
      }
    })
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('页面加载，参数：', options);
    if (!options || !options.id) {
      console.error('缺少必要参数id');
      wx.showToast({
        title: '参数错误',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      id: options.id,
      url: app.globalData.url
    });
    
    this.loadAllData();
  },
  
  // 统一数据加载方法
  loadAllData() {
    wx.showLoading({
      title: '加载中...'
    });
    
    // 并行加载数据
    return Promise.all([
      this.getQuestion(),
      this.getAnswer(),
      this.getPsych()
    ]).finally(() => {
      wx.hideLoading();
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次页面显示时刷新数据，确保显示最新数据
    console.log('页面显示，刷新数据...');
    this.loadAllData();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})